Non-existent methods called on PythonListener

self.listener.get_task_failures(), self.listener.get_final_plan(), and self.listener.reset() are called here, but the actual PythonListener class (in utils/python_benchmark_reporter/PythonListener.py) defines none of these methods. The existing class only exposes notify(), register(), unregister(), register_spark_listener(), and unregister_spark_listener(). Every iteration will raise AttributeError at runtime, making the benchmark completely broken — worse than the state before this PR.

The same breakage exists identically in nds/PysparkBenchReport.py at lines 101–102 and 121.

os.makedirs("") will crash when output_path has no directory component

If self.output_path is a bare filename such as "report.json", then os.path.dirname(self.output_path) returns "", and os.makedirs("", exist_ok=True) raises FileNotFoundError: [Errno 2] No such file or directory: ''. This causes the entire run to fail at the reporting stage after all iterations have completed, silently discarding all collected results.

cleanup_func is invoked before the first iteration

cleanup_func is called unconditionally at the top of every loop iteration, including i = 0. If cleanup requires prior state to exist (e.g., cached tables, temp views, or output from a previous run), calling it before the very first query will either fail or corrupt the initial environment. The common pattern is to call cleanup only between iterations (if i > 0), not before the first one.

Spark listener is never unregistered

self.listener is attached via self.spark.sparkContext.addSparkListener(self.listener) in setup_spark(), but there is no corresponding removal before self.spark.stop(). The old implementation explicitly called listener.unregister(). Without cleanup the listener remains registered until the JVM shuts down, which can cause resource leaks or unexpected callbacks if the session is reused.

Missing newline at end of file

The file ends without a trailing newline (\ No newline at end of file). This is a POSIX violation and can cause issues with some tooling (diff, linters, concatenation). The same issue exists in nds/PysparkBenchReport.py and utils/spark_utils.py.

File is truncated — get_spark_session is incomplete

The function body is cut off mid-expression at line 31 (.config("spark.sql.adaptive.enabled", "true")). The SparkSession.builder chain is never closed with .getOrCreate(), so importing this module will raise a SyntaxError at parse time. The setQueryName and clearQueryName utilities were also entirely removed with no replacement, breaking any caller that relied on them for Spark UI labeling.

// is not valid Python syntax — immediate SyntaxError

// File: nds/PysparkBenchReport.py on line 1 uses C++/JavaScript-style comments, which Python does not recognise. Python will raise SyntaxError: invalid syntax the moment any code attempts to import this module, making the entire file completely unusable. The same problem exists in utils/python_benchmark_reporter/PysparkBenchReport.py (line 1) and utils/spark_utils.py (line 1).

New class interface is completely incompatible with all existing callers

nds/nds_power.py (line 509) and nds/nds_maintenance.py (line 234) both instantiate this class as PysparkBenchReport(spark_session, query_name) and then call .report_on(), .write_summary(), and .is_success(). The new class replaces the constructor signature with PysparkBenchReport(listener, output_dir) and removes all three methods entirely. Every call site will crash with TypeError on construction and AttributeError on method calls — the benchmark is completely broken for every existing user of this module.

Removal of setQueryName and clearQueryName causes ImportError at startup

nds/nds_power.py (line 49) and nds/nds_maintenance.py (line 48) both import these functions: from spark_utils import setQueryName, clearQueryName. Both functions are deleted in this PR. Python evaluates from imports at module load time, so neither nds_power nor nds_maintenance can be imported at all — every benchmark invocation will fail immediately with ImportError: cannot import name 'setQueryName' from 'spark_utils'.

from utils.python_benchmark_reporter import PythonListener imports the module, not the class

PythonListener here refers to the module object utils/python_benchmark_reporter/PythonListener.py, not the PythonListener class defined inside it. In main(), listener = PythonListener() therefore tries to call the module as a constructor and raises TypeError: 'module' object is not callable. The correct import is:

from utils.python_benchmark_reporter.PythonListener import PythonListener

License header incorrectly attributes this file to TPC-H instead of TPC-DS

The original file correctly referenced "TPC-DS version 3.2.0" and the TPC-DS Benchmark. This PR replaces those references with "TPC-H version 3.2.0" and "TPC-H Benchmark". The NDS benchmark is derived from TPC-DS, not TPC-H; this change is factually wrong and introduces a misleading legal/attribution statement into the license header.

Placeholder stub code (tasks = [...]) left in production file

main() contains tasks = [...] # Replace with actual task data — [...] is valid Python (a list containing the Ellipsis object) but it is clearly a stub that was never replaced with real logic. Any invocation of main() will silently pass Ellipsis as a task to process_task, which calls self.listener.notify(...) and appends it to task_failures. This is non-functional placeholder code in a file that will be deployed.

Monkey-patching listener.notify breaks JVM event delivery

self.listener.notify is replaced with a two-argument lambda (et, d), but the Scala JVM bridge calls listener.notify(obj) with a single argument (per the com.nvidia.spark.rapids.listener.Listener interface). After register_with_listener() is called, every Spark event delivery will raise TypeError: <lambda>() missing 1 required positional argument: 'd', silently discarding all task failure and execution plan data — the exact data this reporter is meant to collect.

PythonBenchmarkReporter and SparkBenchmarkReporter delegate to non-existent listener methods

Both PythonBenchmarkReporter and SparkBenchmarkReporter (lines 61, 69, 75 and 96, 104, 110) call self.listener.get_task_failures(), self.listener.get_final_plan(), and self.listener.reset() by direct delegation. The actual PythonListener class defines none of these methods — it only exposes notify, register, unregister, register_spark_listener, and unregister_spark_listener. Any caller that invokes these reporter methods will receive AttributeError at runtime, making both reporter classes completely non-functional.

notify() called with wrong keyword argument — TypeError at runtime

PythonListener.notify is defined as def notify(self, obj) where obj is a plain positional parameter. Calling it as self.listener.notify(event_type="reset") passes a keyword argument that does not match any parameter name, raising TypeError: notify() got an unexpected keyword argument 'event_type' every time reset() is invoked. The __init__ guard validates that notify is callable, giving false confidence that the call site is correct, yet the call itself is broken.

Replacement listener is never registered with Spark

_reset_listener_state() discards the current self.listener and substitutes a freshly constructed PythonListener(), but the new instance is never registered (via listener.register() or listener.register_spark_listener()). After start_benchmark() is called, self.listener points to an inert, unregistered object, so no Spark events are delivered and every subsequent call to collect_metrics() returns an empty result regardless of benchmark activity. The previous listener (registered at construction or by the caller) is silently abandoned.

get_python_benchmark_reporter is an identity function — returns the listener unchanged

The docstring says this function "Creates a Python benchmark reporter instance," but the implementation returns listener unmodified. Any caller expecting a PysparkBenchReport (or any wrapper with start_benchmark(), generate_report(), etc.) will instead receive the raw listener object and hit AttributeError on first method invocation. If wrapping is intentional and deferred, the docstring and return type annotation (object) mask the problem entirely.

register_with_spark / unregister_from_spark pass a spurious argument — TypeError at runtime

PythonListener.register_spark_listener(self) and PythonListener.unregister_spark_listener(self) are defined with no parameters beyond self (confirmed in utils/python_benchmark_reporter/PythonListener.py lines 52–58). Calling them as self.listener.register_spark_listener(spark_session) and self.listener.unregister_spark_listener(spark_session) will raise:

TypeError: register_spark_listener() takes 1 positional argument but 2 were given

Both register_with_spark and unregister_from_spark are therefore completely non-functional.

Hardcoded Spark configs silently override benchmark environment settings

get_spark_session bakes in spark.executor.memory=8g, spark.executor.cores=4, spark.driver.memory=8g, and spark.sql.shuffle.partitions=200 via SparkSession.builder. When called from spark-submit with externally provided --conf flags or a cluster config file, SparkSession.builder.config() calls take precedence and silently override those flags. For a benchmarking tool where hardware sizing is intentional and reproducibility is critical, this means every benchmark run silently uses the same fixed resource profile regardless of the submitted configuration — making cross-environment comparisons meaningless.

cleanup() leaks the Manager registration

cleanup() calls self.listener.unregister_spark_listener() (which removes the Spark event listener via manager.unregisterSparkListener()), but never calls self.listener.unregister() (which deregisters the listener's UUID from the Rapids Manager via manager.unregister(self.uuid)). These are two independent registration steps, both visible in PythonListener.py. After cleanup() returns, the uuid-based handle remains live inside the Manager, preventing garbage collection of the listener object and leaking a JVM-side reference for the remainder of the driver process.

is_spark_active() creates a context instead of checking

SparkContext.getOrCreate() starts a brand-new SparkContext when none is running, so calling is_spark_active() on a fresh process returns True and leaves a live context behind — the exact opposite of a read-only check. Every caller that relies on this to decide whether to initialise Spark will get the wrong answer and may double-create resources. Use the private sentinel SparkContext._active_spark_context to inspect existing state without side effects:

def is_spark_active() -> bool:
    try:
        return SparkContext._active_spark_context is not None  # pylint: disable=protected-access
    except Exception:
        return False

Listener is stored but never queried — report always claims success

collect_metrics() never calls any method on self.listener. The PythonListener instance accepted in the constructor is stored but completely ignored during metric collection. As a result, "success" is hardcoded to True and no Spark event data (task failures, execution plans, job status) ever reaches the report. A benchmark run that fails every task will still produce a report with "success": true and no failure details, silently hiding regressions.

Wait, why is the copyright start-date changing here?

PythonListener constructor called with an argument it does not accept

PythonListener.__init__(self) takes no parameters beyond self, yet line 67 calls PythonListener(sys.argv[1]). At runtime this raises TypeError: __init__() takes 1 positional argument but 2 were given, making the entire main() entry-point permanently unusable regardless of the argument passed.

get_task_failures and get_final_plan both call listener.notify() with no arguments — TypeError at runtime

PythonListener.notify(self, obj) requires the obj positional argument. Both functions call listener.notify() with zero arguments, which raises TypeError: notify() missing 1 required positional argument: 'obj' on every invocation. Additionally, both functions are identical implementations despite having different documented purposes and return types.